home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / network / ncsasock / tcpglue.c < prev    next >
Text File  |  1996-07-05  |  11KB  |  527 lines
  1. /*
  2.  * BSD-style socket emulation library for the Mac
  3.  * Original author: Tom Milligan
  4.  * Current author: Charlie Reiman - creiman@ncsa.uiuc.edu
  5.  *
  6.  * This source file is placed in the public domian.
  7.  * Any resemblance to NCSA Telnet, living or dead, is purely coincidental.
  8.  *
  9.  *      National Center for Supercomputing Applications
  10.  *      152 Computing Applications Building
  11.  *      605 E. Springfield Ave.
  12.  *      Champaign, IL  61820
  13.  */
  14.  
  15. /*
  16.  *    Glue routines to call the MacTCP drivers
  17.  */
  18.  
  19. #ifdef USEDUMP
  20. # pragma load "socket.dump"
  21.  
  22. #else
  23. # include <Memory.h>
  24. # include <Files.h>
  25. # include <Errors.h>
  26.  
  27. # include <s_types.h>
  28. # include <neti_in.h>
  29.  
  30. # include "sock_str.h"
  31.  
  32. # include "sock_int.h"
  33.  
  34. #endif
  35.  
  36. #include <Devices.h>
  37.  
  38. static short driver = 0;
  39.  
  40. /*
  41.  * Hack fix for MacTCP 1.0.X bug
  42.  */
  43.  
  44. #ifdef COMP_CODEWAR
  45. #include <LowMem.h>
  46. #define    ReturnA5(x) LMGetCurrentA5(x)
  47. #else
  48. pascal char *ReturnA5(void) = {0x2E8D};
  49. #endif
  50.  
  51. OSErr xOpenDriver() 
  52. { 
  53.     if (driver == 0) 
  54.     { 
  55.         ParamBlockRec pb; 
  56.         OSErr io; 
  57.         
  58.         pb.ioParam.ioCompletion = 0L; 
  59.         pb.ioParam.ioNamePtr = "\p.IPP"; 
  60.         pb.ioParam.ioPermssn = fsCurPerm; 
  61.         io = PBOpen(&pb,false); 
  62.         if (io != noErr) 
  63.             return(io); 
  64.         driver = pb.ioParam.ioRefNum; 
  65.     }
  66.     return noErr;
  67. }
  68.  
  69.  
  70. /*
  71.  * create a TCP stream
  72.  */
  73. OSErr xTCPCreate(
  74.     int buflen,
  75.     TCPNotifyProc notify,
  76.     TCPiopb *pb)
  77. {    
  78.     TCPNotifyUPP upp= NewTCPNotifyProc(notify);
  79.     
  80.     pb->ioCRefNum = driver;
  81.     pb->csCode = TCPCreate;
  82.     pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
  83.     pb->csParam.create.rcvBuffLen = buflen;
  84.     pb->csParam.create.notifyProc = (TCPNotifyProc) upp;
  85.     return (xPBControlSync(pb));
  86. }
  87.  
  88. /*
  89.  * start listening for a TCP connection
  90.  */
  91. OSErr xTCPPassiveOpen( 
  92.     TCPiopb *pb, 
  93.     short port,
  94.     TCPIOCompletionProc completion)
  95. {
  96.     if (driver == 0)
  97.         return(invalidStreamPtr);
  98.  
  99.     pb->ioCRefNum = driver;
  100.     pb->csCode = TCPPassiveOpen;
  101.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  102.     pb->csParam.open.ulpTimeoutValue = 255 /* was 255 seconds */;
  103.     pb->csParam.open.ulpTimeoutAction = 0 /* 1:abort 0:report */;
  104.     pb->csParam.open.commandTimeoutValue = 0 /* infinity */;
  105.     pb->csParam.open.remoteHost = 0;
  106.     pb->csParam.open.remotePort = 0;
  107.     pb->csParam.open.localHost = 0;
  108.     pb->csParam.open.localPort = port;
  109.     pb->csParam.open.dontFrag = 0;
  110.     pb->csParam.open.timeToLive = 0;
  111.     pb->csParam.open.security = 0;
  112.     pb->csParam.open.optionCnt = 0;
  113.     return (xPBControl(pb,completion));
  114. }
  115.  
  116. /*
  117.  * connect to a remote TCP
  118.  */
  119. OSErr xTCPActiveOpen( 
  120.     TCPiopb *pb, 
  121.     short port,
  122.     long rhost,
  123.     short rport,
  124.     TCPIOCompletionProc completion)
  125. {
  126.     if (driver == 0)
  127.         return(invalidStreamPtr);
  128.  
  129.     pb->ioCRefNum = driver;
  130.     pb->csCode = TCPActiveOpen;
  131.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  132.     pb->csParam.open.ulpTimeoutValue = 20 /* seconds, was 60 */;
  133.     pb->csParam.open.ulpTimeoutAction = 1 /* 1:abort 0:report */;
  134.     pb->csParam.open.commandTimeoutValue = 0;
  135.     pb->csParam.open.remoteHost = rhost;
  136.     pb->csParam.open.remotePort = rport;
  137.     pb->csParam.open.localHost = 0;
  138.     pb->csParam.open.localPort = port;
  139.     pb->csParam.open.dontFrag = 0;
  140.     pb->csParam.open.timeToLive = 0;
  141.     pb->csParam.open.security = 0;
  142.     pb->csParam.open.optionCnt = 0;
  143.     return (xPBControl(pb,completion));
  144. }
  145.  
  146. OSErr xTCPNoCopyRcv( 
  147.     TCPiopb *pb,
  148.     rdsEntry *rds, 
  149.     int rdslen,
  150.     int    timeout,
  151.     TCPIOCompletionProc completion)
  152. {
  153.     
  154.     if (driver == 0)
  155.         return(invalidStreamPtr);
  156.     
  157.     pb->ioCRefNum = driver;
  158.     pb->csCode = TCPNoCopyRcv;
  159.     pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
  160.     pb->csParam.receive.rdsPtr = (Ptr)rds;
  161.     pb->csParam.receive.rdsLength = rdslen;
  162.     return (xPBControl(pb,completion));
  163. }
  164.  
  165. OSErr xTCPBufReturn(TCPiopb *pb,rdsEntry *rds,TCPIOCompletionProc completion)
  166.     {
  167.     pb->ioCRefNum = driver;
  168.     pb->csCode = TCPRcvBfrReturn;
  169.     pb->csParam.receive.rdsPtr = (Ptr)rds;
  170.     
  171.     return (xPBControl(pb,completion));
  172.     }
  173.     
  174. /*
  175.  * send data
  176.  */
  177. OSErr xTCPSend( 
  178.     TCPiopb *pb,
  179.     wdsEntry *wds, 
  180.     Boolean push,
  181.     Boolean urgent,
  182.     TCPIOCompletionProc completion)
  183. {
  184.     if (driver == 0)
  185.         return invalidStreamPtr;
  186.     
  187.     pb->ioCRefNum = driver;
  188.     pb->csCode = TCPSend;
  189.     pb->csParam.send.validityFlags = timeoutValue | timeoutAction;
  190.     pb->csParam.send.ulpTimeoutValue = 20 /* seconds, 60 */;
  191.     pb->csParam.send.ulpTimeoutAction = 0 /* 0:abort 1:report */;
  192.     pb->csParam.send.pushFlag = push;
  193.     pb->csParam.send.urgentFlag = urgent;
  194.     pb->csParam.send.wdsPtr = (Ptr)wds;
  195.     return (xPBControl(pb,completion));
  196. }
  197.  
  198.  
  199. /*
  200.  * close a connection
  201.  */
  202. OSErr xTCPClose(TCPiopb *pb,TCPIOCompletionProc completion) 
  203. {
  204.     if (driver == 0)
  205.         return(invalidStreamPtr);
  206.     
  207.     pb->ioCRefNum = driver;
  208.     pb->csCode = TCPClose;
  209.     pb->csParam.close.validityFlags = timeoutValue | timeoutAction;
  210.     pb->csParam.close.ulpTimeoutValue = 20 /* seconds, 60 */;
  211.     pb->csParam.close.ulpTimeoutAction = 1 /* 1:abort 0:report */;
  212.     return (xPBControl(pb,completion));
  213. }
  214.  
  215. /*
  216.  * abort a connection
  217.  */
  218. OSErr xTCPAbort(TCPiopb *pb) 
  219. {
  220.     if (driver == 0)
  221.         return(invalidStreamPtr);
  222.     
  223.     pb->ioCRefNum = driver;
  224.     pb->csCode = TCPAbort;
  225.     return (xPBControlSync(pb));
  226. }
  227.  
  228. /*
  229.  * close down a TCP stream (aborting a connection, if necessary)
  230.  */
  231. OSErr xTCPRelease( 
  232.     TCPiopb *pb)
  233. {
  234.     OSErr io;
  235.     
  236.     if (driver == 0)
  237.         return(invalidStreamPtr);
  238.     
  239.     pb->ioCRefNum = driver;
  240.     pb->csCode = TCPRelease;
  241.     io = xPBControlSync(pb);
  242.     if (io == noErr)
  243.         DisposPtr(pb->csParam.create.rcvBuff); /* there is no release pb */
  244.     return(io);
  245. }
  246.  
  247. int
  248. xTCPBytesUnread(SocketPtr sp) 
  249. {
  250.     TCPiopb    *pb;
  251.     OSErr io;
  252.     
  253.     if (!(pb = (TCPiopb    *)sock_fetch_pb(sp)))
  254.         return -1;        /* panic */
  255.     
  256.     if (driver == 0)
  257.         return(-1);
  258.     
  259.     pb->ioCRefNum = driver;
  260.     pb->csCode = TCPStatus;
  261.     io = xPBControlSync(pb);
  262.     if (io != noErr)
  263.         return(-1);
  264.     return(pb->csParam.status.amtUnreadData);
  265. }
  266.  
  267. int
  268. xTCPBytesWriteable(SocketPtr sp)
  269.     {
  270.     TCPiopb *pb;
  271.     OSErr    io;
  272.     long    amount;
  273.     
  274.     if (!(pb = (TCPiopb    *)sock_fetch_pb(sp)))
  275.         return -1;        /* panic */
  276.     
  277.     if (driver == 0)
  278.         return(-1);
  279.     
  280.     pb->ioCRefNum = driver;
  281.     pb->csCode = TCPStatus;
  282.     io = xPBControlSync(pb);
  283.     if (io != noErr)
  284.         return(-1);
  285.     amount = pb->csParam.status.sendWindow-pb->csParam.status.amtUnackedData;
  286.     if (amount < 0)
  287.         amount = 0;
  288.     return amount;
  289.     }
  290.     
  291. int xTCPWriteBytesLeft(SocketPtr sp)
  292.     {
  293.     TCPiopb *pb;
  294.     OSErr    io;
  295.     
  296.     if (!(pb = (TCPiopb    *)sock_fetch_pb(sp)))
  297.         return -1;        /* panic */
  298.     
  299.     if (driver == 0)
  300.         return(-1);
  301.     
  302.     pb->ioCRefNum = driver;
  303.     pb->csCode = TCPStatus;
  304.     io = xPBControlSync(pb);
  305.     if (io != noErr)
  306.         return(-1);
  307.     return (pb->csParam.status.amtUnackedData);
  308.     }
  309.  
  310. int xTCPState(TCPiopb *pb)
  311.     {
  312.     OSErr io;
  313.     
  314.     if (driver == 0)
  315.         return(-1);
  316.     
  317.     pb->ioCRefNum = driver;
  318.     pb->csCode = TCPStatus;
  319.     io = xPBControlSync(pb);
  320.     if (io != noErr)
  321.         return(-1);
  322.     return(pb->csParam.status.connectionState);
  323.     }
  324.  
  325.  
  326. /*
  327.  * create a UDP stream, hook it to a socket.
  328.  */
  329. OSErr xUDPCreate(SocketPtr sp,int buflen,ip_port port)
  330.     {    
  331.     UDPiopb *pb;
  332.     OSErr   io;
  333.     
  334.     if ( !(pb = (UDPiopb *)sock_fetch_pb(sp) ) )
  335.         return -1;
  336.     
  337.     pb->ioCRefNum = driver;
  338.     pb->csCode = UDPCreate;
  339.     pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
  340.     pb->csParam.create.rcvBuffLen = buflen;
  341.     pb->csParam.create.notifyProc = NULL;
  342.     pb->csParam.create.localPort = port;
  343.     if ( (io = xPBControlSync( (TCPiopb *)pb ) ) != noErr)
  344.         return io;
  345.         
  346.     sp->stream = pb->udpStream;
  347.     sp->sa.sin_port = pb->csParam.create.localPort;
  348.     return noErr;
  349.     }
  350.  
  351. /*
  352.  * ask for incoming data
  353.  */
  354. OSErr xUDPRead(SocketPtr sp,UDPIOCompletionProc completion) 
  355.     {
  356.     UDPiopb *pb;
  357.     
  358.     if ( !(pb = (UDPiopb *)sock_fetch_pb(sp) ))
  359.         return -1;
  360.     
  361.     if (driver == 0)
  362.         return(invalidStreamPtr);
  363.     
  364.     pb->ioCRefNum = driver;
  365.     pb->csCode = UDPRead;
  366.     pb->csParam.receive.timeOut = 0 /* infinity */;
  367.     pb->csParam.receive.secondTimeStamp = 0/* must be zero */;
  368.     return (xPBControl ( (TCPiopb *)pb, (TCPIOCompletionProc)completion ));
  369.     }
  370.  
  371. OSErr xUDPBfrReturn(SocketPtr sp) 
  372.     {
  373.     UDPiopb *pb;
  374.  
  375.     if ( !(pb = (UDPiopb *)sock_fetch_pb(sp) ))
  376.         return -1;
  377.  
  378.     if (driver == 0)
  379.         return(invalidStreamPtr);
  380.     
  381.     pb->ioCRefNum = driver;
  382.     pb->csCode = UDPBfrReturn;
  383.     pb->csParam.receive.rcvBuff = sp->recvBuf;
  384.     sp->recvBuf = 0;
  385.     sp->recvd   = 0;
  386.     return ( xPBControl( (TCPiopb *)pb,(TCPIOCompletionProc)-1 ) );
  387.     }
  388.  
  389. /*
  390.  * send data
  391.  */
  392. OSErr xUDPWrite(SocketPtr sp,ip_addr host,ip_port port,miniwds *wds,
  393.         UDPIOCompletionProc completion) 
  394.     {
  395.     UDPiopb    *pb;
  396.     
  397.     if ( !(pb = (UDPiopb *)sock_fetch_pb(sp) ))
  398.         return -1;
  399.         
  400.     if (driver == 0)
  401.         return(invalidStreamPtr);
  402.     
  403.     pb->ioCRefNum = driver;
  404.     pb->csCode = UDPWrite;
  405.     pb->csParam.send.remoteHost = host;
  406.     pb->csParam.send.remotePort = port;
  407.     pb->csParam.send.wdsPtr = (Ptr)wds;
  408.     pb->csParam.send.checkSum = true;
  409.     pb->csParam.send.sendLength = 0/* must be zero */;
  410.     return (xPBControl( (TCPiopb *)pb, (TCPIOCompletionProc)completion));
  411.     }
  412.  
  413. /*
  414.  * close down a UDP stream (aborting a read, if necessary)
  415.  */
  416. OSErr xUDPRelease(SocketPtr sp) {
  417.     UDPiopb *pb;
  418.     OSErr io;
  419.  
  420.     if ( !(pb = (UDPiopb *)sock_fetch_pb(sp) ))
  421.         return -1;
  422.     
  423.     if (driver == 0)
  424.         return(invalidStreamPtr);
  425.     
  426.     pb->ioCRefNum = driver;
  427.     pb->csCode = UDPRelease;
  428.     io = xPBControlSync( (TCPiopb *)pb );
  429.     if (io == noErr) {
  430.         DisposPtr(pb->csParam.create.rcvBuff);
  431.         }
  432.     return(io);
  433.     }
  434.  
  435. ip_addr xIPAddr(void) 
  436. {
  437.     struct GetAddrParamBlock pbr; /* was IPParamBlock pbr; */
  438.     OSErr io;
  439.     
  440.     pbr.ioCRefNum = driver;
  441.     pbr.csCode = ipctlGetAddr;
  442.     io = xPBControlSync( (TCPiopb *)&pbr );
  443.     if (io != noErr)
  444.         return(0);
  445.     return(pbr.ourAddress);/*IPEchoPB.dest ?? */
  446. }
  447.  
  448. long xNetMask() 
  449. {
  450.     struct GetAddrParamBlock pbr; /* was IPParamBlock pbr; */
  451.     OSErr io;
  452.     
  453.     pbr.ioCRefNum = driver;
  454.     pbr.csCode = ipctlGetAddr;
  455.     io = xPBControlSync( (TCPiopb *)&pbr);
  456.     if (io != noErr)
  457.         return(0);
  458.     return(pbr.ourNetMask);  
  459. }
  460.  
  461. unsigned short xMaxMTU()
  462. {
  463.     struct UDPiopb pbr;
  464.     OSErr io;
  465.     
  466.     pbr.ioCRefNum = driver;
  467.     pbr.csCode = UDPMaxMTUSize;
  468.     pbr.csParam.mtu.remoteHost = xIPAddr();
  469.     io = xPBControlSync( (TCPiopb *)&pbr );
  470.     if (io != noErr)
  471.         return(0);
  472.     return(pbr.csParam.mtu.mtuSize);
  473. }
  474.  
  475. OSErr xPBControlSync(TCPiopb *pb) 
  476. { 
  477.     (pb)->ioCompletion = 0L; 
  478.     return PBControl((ParmBlkPtr)(pb),false); 
  479. }
  480.  
  481. #ifndef COMP_CODEWAR
  482. #pragma segment SOCK_RESIDENT
  483. #endif
  484.  
  485. OSErr xTCPRcv( 
  486.     TCPiopb *pb,
  487.     Ptr buf, 
  488.     int buflen,
  489.     int    timeout,
  490.     TCPIOCompletionProc completion)
  491. {
  492.     
  493.     if (driver == 0)
  494.         return(invalidStreamPtr);
  495.     
  496.     pb->ioCRefNum = driver;
  497.     pb->csCode = TCPRcv;
  498.     pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
  499.     pb->csParam.receive.rcvBuff = buf;
  500.     pb->csParam.receive.rcvBuffLen = buflen;
  501.     return (xPBControl(pb,completion));
  502. }
  503.  
  504.  
  505. OSErr xPBControl(TCPiopb *pb,TCPIOCompletionProc completion) 
  506. { 
  507.     pb->ioNamePtr = ReturnA5();
  508.     
  509.     if (completion == 0L) 
  510.     { 
  511.         (pb)->ioCompletion = 0L; 
  512.         return(PBControl((ParmBlkPtr)(pb),false));        /* sync */
  513.     } 
  514.     else if (completion == (TCPIOCompletionProc)-1L) 
  515.     { 
  516.         (pb)->ioCompletion = 0L; 
  517.         return(PBControl((ParmBlkPtr)(pb),true));        /* async */
  518.     } 
  519.     else 
  520.     {  
  521.         TCPIOCompletionUPP upp= NewTCPIOCompletionProc(completion);
  522.         (pb)->ioCompletion = (TCPIOCompletionProc) upp; 
  523.         return(PBControl((ParmBlkPtr)(pb),true));        /* async */
  524.     } 
  525. }
  526.  
  527.